home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / Utilities / Remotes / Source / StuartSpeaker.m < prev   
Encoding:
Text File  |  1992-09-23  |  4.3 KB  |  193 lines

  1. /* Copyright (c) 1990, 1992, Scott Hess.  No rights reserved.  No
  2.  * warranty is provided for this software, neither explicit nor
  3.  * implied.  The source and object code for this file may be used
  4.  * and modified as the user sees fit.
  5.  */
  6. #import "StuartSpeaker.h"
  7. #import <appkit/Listener.h>
  8. #import <libc.h>
  9. #import <math.h>
  10. #import <stdio.h>
  11. #import <strings.h>
  12.  
  13. extern id NXResponsibleDelegate();
  14.  
  15. @implementation  StuartSpeaker
  16. - init
  17. {
  18.     self=[super init];
  19.     if( self) {
  20.     defaults=[[NXStringTable allocFromZone:[self zone]] init];
  21.     }
  22.     return self;
  23. }
  24. - free
  25. {
  26.     /* Since I was storing static strings in defaults, I don't want
  27.      * them to be freed by the NXStringTable code.
  28.      */
  29.     [defaults empty];
  30.     defaults=[defaults free];
  31.     return [super free];
  32. }
  33. -(int)_stuartNew:(char *)defs activate:(int)flag
  34. {
  35.     return [self selectorRPC:"_stuartNew:activate:" paramTypes:"ci", defs, flag];
  36. }
  37. -(int)_stuartGet:(char **)defs
  38. {
  39.     return [self selectorRPC:"_stuartGet:" paramTypes:"C", defs];
  40. }
  41. static const char *sValue;        // a temp variable.
  42. static char buffer[ 1024];
  43. const char *itoa( int i)
  44. {
  45.     sprintf( buffer, "%d", i);
  46.     return buffer;
  47. }
  48. const char *ftoa( float f)
  49. {
  50.     sprintf( buffer, "%f", f);
  51.     return buffer;
  52. }
  53. const char *btoa( BOOL b)
  54. {
  55.     sprintf( buffer, "%s", b ? "YES" : "NO");
  56.     return buffer;
  57. }
  58. BOOL atob( const char *s)
  59. {
  60.     if( !s) {
  61.     return NO;
  62.     } else if( !*s) {
  63.     return YES;
  64.     } else if( !strcmp( s, "YES")) {
  65.     return YES;
  66.     } else {
  67.     return atoi( s)!=0;
  68.     }
  69. }
  70. -(const char *)default:(const char *)name
  71. {
  72.     return [defaults valueForStringKey:name];
  73. }
  74. -(int)defaultAsInt:(const char *)name
  75. {
  76.     return (sValue=[self default:name]) ? atoi( sValue) : 0;
  77. }
  78. -(float)defaultAsFloat:(const char *)name
  79. {
  80.     return (sValue=[self default:name]) ? atof( sValue) : NAN;
  81. }
  82. -(BOOL)defaultAsBOOL:(const char *)name
  83. {
  84.     return (sValue=[self default:name]) ? atob( sValue) : NO;
  85. }
  86. - default:(const char *)name as:(const char *)value
  87. {
  88.     return [defaults insertKey:(void *)name value:(void *)value];
  89. }
  90. - default:(const char *)name asInt:(int)value
  91. {
  92.     return [self default:name as:itoa( value)];
  93. }
  94. - default:(const char *)name asFloat:(float)value
  95. {
  96.     return [self default:name as:ftoa( value)];
  97. }
  98. - default:(const char *)name asBOOL:(BOOL)value
  99. {
  100.     return [self default:name as:btoa( value)];
  101. }
  102. - removeDefault:(const char *)name
  103. {
  104.     [defaults removeKey:(void *)name];
  105.     return self;
  106. }
  107.  
  108. -(int)stuartNew
  109. {
  110.     int i=-1;
  111.     NXStream *aStream=NXOpenMemory( NULL, 0, NX_WRITEONLY);
  112.     if( aStream) {
  113.     char *data;
  114.     int len, maxLen;
  115.     BOOL activate=[self defaultAsBOOL:"Activate"];
  116.     [self removeDefault:"Activate"];
  117.     [defaults writeToStream:aStream];
  118.     NXPutc( aStream, '\0');
  119.     NXGetMemoryBuffer( aStream, &data, &len, &maxLen);
  120.     i=[self _stuartNew:data activate:activate];
  121.     NXCloseMemory( aStream, NX_FREEBUFFER);
  122.     }
  123.     return i;
  124. }
  125. -(int)stuartGet
  126. {
  127.     NXStream *aStream;
  128.     int i, len;
  129.     char *defs;
  130.     i=[self _stuartGet:&defs];
  131.     if( i) {
  132.     return i;
  133.     }
  134.     len=strlen( defs);
  135.     aStream=NXOpenMemory( defs, len, NX_READONLY);
  136.     if( aStream) {
  137.     [defaults readFromStream:aStream];
  138.     NXCloseMemory( aStream, NX_FREEBUFFER);
  139.     }
  140.     return 0;
  141. }
  142. -(int)stuartSend:(int)fd
  143. {
  144.     int ret=0;
  145.     NXStream *aStream=NXOpenFile( fd, NX_READONLY);
  146.     if( aStream) {
  147.     [defaults readFromStream:aStream];
  148.     ret=[self stuartNew];
  149.     NXClose( aStream);
  150.     }
  151.     return ret;
  152. }
  153. -(int)stuartConnectAndNew
  154. {
  155.     int ret=-1;
  156.     port_t stuartPort=NXPortFromName( "Stuart", [self default:"NXHost"]);
  157.     [self removeDefault:"NXHost"];
  158.     if( stuartPort!=PORT_NULL) {
  159.     [self setSendPort:stuartPort];
  160.     ret=[self stuartNew];
  161.     } else {
  162.     fprintf( stderr, "Stuart not running\n");
  163.     }
  164.     return ret;
  165. }
  166. -(int)stuartConnectAndGet
  167. {
  168.     int ret=-1;
  169.     port_t stuartPort=NXPortFromName( "Stuart", [self default:"NXHost"]);
  170.     [self removeDefault:"NXHost"];
  171.     if( stuartPort!=PORT_NULL) {
  172.     [self setSendPort:stuartPort];
  173.     ret=[self stuartGet];
  174.     } else {
  175.     fprintf( stderr, "Stuart not running\n");
  176.     }
  177.     return ret;
  178. }
  179. -(int)stuartConnectAndSend:(int)fd
  180. {
  181.     int ret=-1;
  182.     port_t stuartPort=NXPortFromName( "Stuart", [self default:"NXHost"]);
  183.     [self removeDefault:"NXHost"];
  184.     if( stuartPort!=PORT_NULL) {
  185.     [self setSendPort:stuartPort];
  186.     ret=[self stuartSend:fd];
  187.     } else {
  188.     fprintf( stderr, "Stuart not running\n");
  189.     }
  190.     return ret;
  191. }
  192. @end
  193.